home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Tool Chest / Text / WASTE / WASTE 1.1.2 Distribution / WASTE Source / WEObjects.p < prev    next >
Encoding:
Text File  |  1995-10-12  |  18.2 KB  |  635 lines  |  [TEXT/CWIE]
  1. unit WEObjects;
  2.  
  3. { WASTE PROJECT: }
  4. { Embedded Objects }
  5.  
  6. { Copyright © 1993-1995 Marco Piovanelli }
  7. { All Rights Reserved }
  8.  
  9. interface
  10.     uses
  11.         WEDebug;
  12.  
  13.     const
  14.  
  15. { values for WEInstallObjectHandler handlerSelector parameter }
  16.  
  17.         weNewHandler = 'new ';
  18.         weDisposeHandler = 'free';
  19.         weDrawHandler = 'draw';
  20.         weClickHandler = 'clik';
  21.         weCursorHandler = 'curs';
  22.  
  23.     type
  24.  
  25. { A WESoup record is a static description of an object embedded in the text. }
  26. { The 'SOUP' data type is just a collection of WESoup records, each followed }
  27. { by the corresponding object data. }
  28. { This data type complements the standard TEXT/styl pair. }
  29.  
  30.         WESoup = record
  31.                 soupOffset: LongInt;                    { insertion offset for this object }
  32.                 soupType: OSType;                    { 4-letter tag identifying object type }
  33.                 soupReserved1: LongInt;            { reserved for future use; set to zero }
  34.                 soupDataSize: Size;                    { size of object data following this record }
  35.                 soupSize: Point;                            { object height and width, in pixels }
  36.                 soupReserved2: LongInt;            { reserved for future use; set to zero }
  37. { actual object data follows }
  38.             end;  { WESoup }
  39.         WESoupPtr = ^WESoup;
  40.         WESoupHandle = ^WESoupPtr;
  41.  
  42. { A WEObjectDesc record is used to keep track of embedded objects in memory. }
  43. { Notice that the first two fields are an AEDesc record, i.e. "tagged data" }
  44.  
  45.         WEObjectDesc = record
  46.                 objectType: OSType;                        { 4-letter tag identifying object type }
  47.                 objectDataHandle: Handle;            { handle to object data }
  48.                 objectSize: Point;                            { object height and width, in pixels }
  49.                 objectTable: Handle;                        { handle to object handler table }
  50.                 objectIndex: Integer;                    { precalculated index into object handler table }
  51.                 objectOwner: WEHandle;                { handle to owner WE instance }
  52.                 objectRefCon: LongInt;                    { free for use by object handlers }
  53.             end;  { WEObjectDesc }
  54.         WEObjectDescPtr = ^WEObjectDesc;
  55.         WEObjectDescHandle = ^WEObjectDescPtr;
  56.  
  57.         WEObjectReference = WEObjectDescHandle;
  58.  
  59.     type
  60.  
  61. { callback prototypes and UPPs }
  62.  
  63. { FUNCTION MyNewObject (VAR defaultObjectSize: Point; objectRef: WEObjectReference): OSErr; }
  64.         WENewObjectProcPtr = ProcPtr;
  65.         WENewObjectUPP = UniversalProcPtr;
  66.  
  67. { FUNCTION MyDisposeObject (objectRef: WEObjectReference): OSErr; }
  68.         WEDisposeObjectProcPtr = ProcPtr;
  69.         WEDisposeObjectUPP = UniversalProcPtr;
  70.  
  71. { FUNCTION MyDrawObject (destRect: Rect; objectRef : WEObjectReference): OSErr; }
  72.         WEDrawObjectProcPtr = ProcPtr;
  73.         WEDrawObjectUPP = UniversalProcPtr;
  74.  
  75. { FUNCTION MyClickObject (hitPt: Point; modifiers: EventModifiers; }
  76. {         clickTime: LongInt; objectRef: WEObjectReference): Boolean; }
  77.         WEClickObjectProcPtr = ProcPtr;
  78.         WEClickObjectUPP = UniversalProcPtr;
  79.  
  80.     const
  81.  
  82. { UPP proc info }
  83.  
  84.         uppWENewObjectProcInfo = $000003E0;
  85.         uppWEDisposeObjectProcInfo = $000000E0;
  86.         uppWEDrawObjectProcInfo = $000003E0;
  87.         uppWEClickObjectProcInfo = $00003ED0;
  88.  
  89. { New "macros" }
  90.  
  91.     function NewWENewObjectProc (userRoutine: WENewObjectProcPtr): WENewObjectUPP;
  92. {$IFC NOT GENERATINGCFM}
  93.     inline
  94.         $2E9F;
  95. {$ENDC}
  96.  
  97.     function NewWEDisposeObjectProc (userRoutine: WEDisposeObjectProcPtr): WEDisposeObjectUPP;
  98. {$IFC NOT GENERATINGCFM}
  99.     inline
  100.         $2E9F;
  101. {$ENDC}
  102.  
  103.     function NewWEDrawObjectProc (userRoutine: WEDrawObjectProcPtr): WEDrawObjectUPP;
  104. {$IFC NOT GENERATINGCFM}
  105.     inline
  106.         $2E9F;
  107. {$ENDC}
  108.  
  109.     function NewWEClickObjectProc (userRoutine: WEClickObjectProcPtr): WEClickObjectUPP;
  110. {$IFC NOT GENERATINGCFM}
  111.     inline
  112.         $2E9F;
  113. {$ENDC}
  114.  
  115. { Call "macros" }
  116.  
  117.     function CallWENewObjectProc (var defaultObjectSize: Point;
  118.                                     objectRef: WEObjectReference;
  119.                                     userRoutine: WENewObjectUPP): OSErr;
  120. {$IFC NOT GENERATINGCFM}
  121.     inline
  122.         $205F, $4E90;
  123. {$ENDC}
  124.  
  125.     function CallWEDisposeObjectProc (objectRef: WEObjectReference;
  126.                                     userRoutine: WEDisposeObjectUPP): OSErr;
  127. {$IFC NOT GENERATINGCFM}
  128.     inline
  129.         $205F, $4E90;
  130. {$ENDC}
  131.  
  132.     function CallWEDrawObjectProc ({const} var destRect: Rect;
  133.                                     objectRef: WEObjectReference;
  134.                                     userRoutine: WEDrawObjectUPP): OSErr;
  135. {$IFC NOT GENERATINGCFM}
  136.     inline
  137.         $205F, $4E90;
  138. {$ENDC}
  139.  
  140.     function CallWEClickObjectProc (hitPoint: Point;
  141.                                     modifiers: EventModifiers;
  142.                                     clickTime: LongInt;
  143.                                     objectRef: WEObjectReference;
  144.                                     userRoutine: WEClickObjectUPP): Boolean;
  145. {$IFC NOT GENERATINGCFM}
  146.     inline
  147.         $205F, $4E90;
  148. {$ENDC}
  149.  
  150.  
  151. { embedded object functions for use by the client application }
  152.  
  153.     function WEInstallObjectHandler (objectType: OSType;
  154.                                     handlerSelector: OSType;
  155.                                     handler: UniversalProcPtr;
  156.                                     hWE: WEHandle): OSErr;
  157.  
  158. { accessor functions for use by object handlers }
  159.  
  160.     function WEGetObjectType (hObjectDesc: WEObjectDescHandle): OSType;
  161.     function WEGetObjectDataHandle (hObjectDesc: WEObjectDescHandle): Handle;
  162.     function WEGetObjectSize (hObjectDesc: WEObjectDescHandle): Point;
  163.     function WEGetObjectOwner (hObjectDesc: WEObjectDescHandle): WEHandle;
  164.     function WEGetObjectRefCon (hObjectDesc: WEObjectDescHandle): LongInt;
  165.     procedure WESetObjectRefCon (hObjectDesc: WEObjectDescHandle;
  166.                                     refCon: LongInt);
  167.  
  168. { object management function for WASTE internal use }
  169.  
  170.     function _WENewObject (objectType: OSType;
  171.                                     objectDataHandle: Handle;
  172.                                     hWE: WEHandle;
  173.                                     var hObjectDesc: WEObjectDescHandle): OSErr;
  174.     function _WEFreeObject (hObjectDesc: WEObjectDescHandle): OSErr;
  175.     function _WEDrawObject (hObjectDesc: WEObjectDescHandle): OSErr;
  176.     function _WEClickObject (hitPt: Point;
  177.                                     modifiers: EventModifiers;
  178.                                     clickTime: LongInt;
  179.                                     hObjectDesc: WEObjectDescHandle): Boolean;
  180.     function _WEGetIndObjectType (index: Integer;
  181.                                     var objectType: OSType;
  182.                                     hWE: WEHandle): OSErr;
  183.  
  184. implementation
  185.     uses
  186.         ToolUtils;
  187.  
  188.     const
  189.  
  190.         kUnknownObjectType = -1;                { specifies an object type for which no handlers are installed }
  191.         kDefaultObjectSize = $00200020;        { default object size (32x32 pixels) }
  192.  
  193.     type
  194.  
  195.         WEOHTableElement = record
  196.                 objectType: OSType;                { 4-letter tag identifying object type }
  197.                 newHandler: WENewObjectUPP;
  198.                 freeHandler: WEDisposeObjectUPP;
  199.                 drawHandler: WEDrawObjectUPP;
  200.                 clickHandler: WEClickObjectUPP;
  201.                 cursorHandler: UniversalProcPtr;
  202.             end;  { WEOHTableElement }
  203.         WEOHTableElementPtr = ^WEOHTableElement;
  204.  
  205.         WEOHTable = array[0..0] of WEOHTableElement;
  206.         WEOHTablePtr = ^WEOHTable;
  207.         WEOHTableHandle = ^WEOHTablePtr;
  208.  
  209.     var
  210.  
  211. { static variables }
  212.  
  213.         _weGlobalObjectHandlerTable: Handle;
  214.  
  215.     function WEGetObjectType (hObjectDesc: WEObjectDescHandle): OSType;
  216.     begin
  217.         WEGetObjectType := hObjectDesc^^.objectType;
  218.     end;  { WEGetObjectType }
  219.  
  220.     function WEGetObjectDataHandle (hObjectDesc: WEObjectDescHandle): Handle;
  221.     begin
  222.         WEGetObjectDataHandle := hObjectDesc^^.objectDataHandle;
  223.     end;  { WEGetObjectDataHandle }
  224.  
  225.     function WEGetObjectSize (hObjectDesc: WEObjectDescHandle): Point;
  226.     begin
  227.         WEGetObjectSize := hObjectDesc^^.objectSize;
  228.     end;  { WEGetObjectSize }
  229.  
  230.     function WEGetObjectOwner (hObjectDesc: WEObjectDescHandle): WEHandle;
  231.     begin
  232.         WEGetObjectOwner := hObjectDesc^^.objectOwner;
  233.     end;  { WEGetObjectOwner }
  234.  
  235.     function WEGetObjectRefCon (hObjectDesc: WEObjectDescHandle): LongInt;
  236.     begin
  237.         WEGetObjectRefCon := hObjectDesc^^.objectRefCon;
  238.     end;  { WEGetObjectRefCon }
  239.  
  240.     procedure WESetObjectRefCon (hObjectDesc: WEObjectDescHandle;
  241.                                     refCon: LongInt);
  242.     begin
  243.         hObjectDesc^^.objectRefCon := refCon;
  244.     end;  { WESetObjectRefCon }
  245.  
  246.     function _WELookupObjectType (objectType: OSType;
  247.                                     hTable: Handle): Integer;
  248.  
  249. { look for a WEOHTableElement record for the specified object kind }
  250. { in the given object handler table }
  251.  
  252.         var
  253.             nEntries, index: Integer;
  254.     begin
  255.  
  256. { assume no handlers have been installed for this object type }
  257.         _WELookupObjectType := kUnknownObjectType;
  258.  
  259. { do nothing if the Object Handler Table has not been inited yet }
  260.         if (hTable = nil) then
  261.             Exit(_WELookupObjectType);
  262.  
  263. { calculate entry count }
  264.         nEntries := Integer(GetHandleSize(hTable)) div SizeOf(WEOHTableElement);
  265.  
  266. { scan the Object Handler Table looking for a type match }
  267.         for index := nEntries - 1 downto 0 do
  268.             if (WEOHTableHandle(hTable)^^[index].objectType = objectType) then
  269.                 begin
  270.                     _WELookupObjectType := index;
  271.                     Exit(_WELookupObjectType);
  272.                 end;
  273.     end;  { _WELookupObjectType }
  274.  
  275.     function _WEGetIndObjectType (index: Integer;
  276.                                     var objectType: OSType;
  277.                                     hWE: WEHandle): OSErr;
  278.         label
  279.             0, 1;
  280.         var
  281.             hTable: Handle;
  282.             nEntries: Integer;
  283.             err: OSErr;
  284.     begin
  285.         err := weUnknownObjectTypeErr;    { assume failure }
  286.         objectType := OSType(0);
  287.  
  288. { index must be non-negative }
  289.         if (index < 0) then
  290.             goto 1;
  291.  
  292. { calculate number of entries in the instance-specific handler table }
  293.         nEntries := 0;
  294.         hTable := hWE^^.hObjectHandlerTable;
  295.         if (hTable <> nil) then
  296.             nEntries := Integer(GetHandleSize(hTable)) div SizeOf(WEOHTableElement);
  297.  
  298. { low indices refer to the instance-specific handler table }
  299.         if (index < nEntries) then
  300.             begin
  301.                 objectType := WEOHTableHandle(hTable)^^[index].objectType;
  302.                 goto 0;
  303.             end;
  304.  
  305. { indices above that refer to the global handler table }
  306.         index := index - nEntries;
  307.  
  308. { calculate number of entries in the global handler table }
  309.         nEntries := 0;
  310.         hTable := _weGlobalObjectHandlerTable;
  311.         if (hTable <> nil) then
  312.             nEntries := Integer(GetHandleSize(hTable)) div SizeOf(WEOHTableElement);
  313.  
  314. { return an error code if index is too large }
  315.         if (index >= nEntries) then
  316.             goto 1;
  317.  
  318.         objectType := WEOHTableHandle(hTable)^^[index].objectType;
  319.  
  320. 0:
  321. { clear result code }
  322.         err := noErr;
  323.  
  324. 1:
  325. { return result code }
  326.         _WEGetIndObjectType := err;
  327.  
  328.     end;  { _WEGetIndObjectType }
  329.  
  330.     function _WENewObject (objectType: OSType;
  331.                                     objectDataHandle: Handle;
  332.                                     hWE: WEHandle;
  333.                                     var hObjectDesc: WEObjectDescHandle): OSErr;
  334.         label
  335.             1;
  336.         var
  337.             hTable: Handle;
  338.             pDesc: WEObjectDescPtr;
  339.             index: Integer;
  340.             err: OSErr;
  341.     begin
  342.         _WENewObject := noErr;
  343.         hObjectDesc := nil;
  344.  
  345. { first look up the specified object type in the instance-specific handler table }
  346.         hTable := hWE^^.hObjectHandlerTable;
  347.         index := _WELookupObjectType(objectType, hTable);
  348.         if (index = kUnknownObjectType) then
  349.             begin
  350.  
  351. { no match: try with the global handler table }
  352.                 hTable := _weGlobalObjectHandlerTable;
  353.                 index := _WELookupObjectType(objectType, hTable);
  354.                 if (index = kUnknownObjectType) then
  355.                     hTable := nil;
  356.             end;
  357.  
  358. { create a new relocatable block to hold the object descriptor }
  359.         err := _WEAllocate(SizeOf(WEObjectDesc), kAllocClear, hObjectDesc);
  360.         if (err <> noErr) then
  361.             goto 1;
  362.  
  363. { lock it down }
  364.         HLock(Handle(hObjectDesc));
  365.         pDesc := hObjectDesc^;
  366.  
  367. { fill in the object descriptor }
  368.         pDesc^.objectType := objectType;
  369.         pDesc^.objectDataHandle := objectDataHandle;
  370.         pDesc^.objectSize := Point(kDefaultObjectSize);
  371.         pDesc^.objectTable := hTable;
  372.         pDesc^.objectIndex := index;
  373.         pDesc^.objectOwner := hWE;
  374.  
  375.         if (hTable <> nil) then
  376.             with WEOHTableHandle(hTable)^^[index] do
  377.  
  378. { call the new handler, if any }
  379.                 if (newHandler <> nil) then
  380.                     begin
  381.                         err := CallWENewObjectProc(pDesc^.objectSize, hObjectDesc, newHandler);
  382.                         if (err <> noErr) then
  383.                             begin
  384.                                 _WEForgetHandle(hObjectDesc);
  385.                                 goto 1;
  386.                             end;
  387.                     end;
  388.  
  389. { unlock the object descriptor }
  390.         HUnlock(Handle(hObjectDesc));
  391.  
  392. { clear result code }
  393.         err := noErr;
  394.  
  395. 1:
  396. { return result code }
  397.         _WENewObject := err;
  398.  
  399.     end;  { _WENewObject }
  400.  
  401.     function _WEFreeObject (hObjectDesc: WEObjectDescHandle): OSErr;
  402.         var
  403.             pDesc: WEObjectDescPtr;
  404.     begin
  405.         _WEFreeObject := noErr;
  406.  
  407. { sanity check: do nothing if we have a null descriptor handle }
  408.         if (hObjectDesc = nil) then
  409.             begin
  410.                 _WEFreeObject := nilHandleErr;
  411.                 Exit(_WEFreeObject);
  412.             end;
  413.  
  414. { lock the descriptor record }
  415.         HLock(Handle(hObjectDesc));
  416.         pDesc := hObjectDesc^;
  417.  
  418.         if (pDesc^.objectTable <> nil) then
  419.             with WEOHTableHandle(pDesc^.objectTable)^^[pDesc^.objectIndex] do
  420.                 begin
  421.  
  422. {$IFC WASTE_DEBUG}
  423. { sanity check: make sure object kind matches handler kind }
  424.                     _WEAssert(pDesc^.objectType = objectType, 'Object Type Mismatch');
  425. {$ENDC}
  426.  
  427. { call the dispose handler, if any }
  428.                     if (freeHandler <> nil) then
  429.                         begin
  430.                             _WEFreeObject := CallWEDisposeObjectProc(hObjectDesc, freeHandler);
  431.                             pDesc^.objectDataHandle := nil;
  432.                         end;
  433.                 end;
  434.  
  435. { if object kind is unknown or there's no custom dispose handler, use DisposeHandle }
  436.         _WEForgetHandle(pDesc^.objectDataHandle);
  437.  
  438. { finally, dispose of the object descriptor itself }
  439.         DisposeHandle(Handle(hObjectDesc));
  440.  
  441.     end;  { _WEFreeObject }
  442.  
  443.     function _WEDrawObject (hObjectDesc: WEObjectDescHandle): OSErr;
  444.         var
  445.             pDesc: WEObjectDescPtr;
  446.             destRect: Rect;
  447.             state: PenState;
  448.             saveDescLock: Boolean;
  449.     begin
  450.         _WEDrawObject := noErr;
  451.  
  452. { lock the object descriptor }
  453.         saveDescLock := _WESetHandleLock(hObjectDesc, true);
  454.         pDesc := hObjectDesc^;
  455.  
  456. { get current pen state }
  457. { state.pnLoc has already been set to the bottom left of the rectangle to draw }
  458.         GetPenState(state);
  459.  
  460. { calculate the new pen position }
  461.         state.pnLoc.h := state.pnLoc.h + pDesc^.objectSize.h;
  462.  
  463. { calculate the object destination rectangle }
  464.         destRect.topLeft := Point(DeltaPoint(state.pnLoc, pDesc^.objectSize));
  465.         destRect.botRight := state.pnLoc;
  466.  
  467.         if (pDesc^.objectTable <> nil) then
  468.             with WEOHTableHandle(pDesc^.objectTable)^^[pDesc^.objectIndex] do
  469.                 begin
  470.  
  471. {$IFC WASTE_DEBUG}
  472. { sanity check: make sure object kind matches handler kind }
  473.                     _WEAssert(pDesc^.objectType = objectType, 'Object Type Mismatch');
  474. {$ENDC}
  475.  
  476. { call the drawing handler, if any }
  477.                     if (drawHandler <> nil) then
  478.                         _WEDrawObject := CallWEDrawObjectProc(destRect, hObjectDesc, drawHandler);
  479.  
  480.                 end
  481.         else
  482.             begin
  483.  
  484. { if this object kind was not registered, draw an empty frame }
  485.                 PenNormal;
  486.                 FrameRect(destRect);
  487.             end;
  488.  
  489. { restore original pen state, advancing the pen position by the object width }
  490.         SetPenState(state);
  491.  
  492. { unlock the object descriptor }
  493.         if (_WESetHandleLock(hObjectDesc, saveDescLock)) then
  494.             ;
  495.  
  496.     end;  { _WEDrawObject }
  497.  
  498.     function _WEClickObject (hitPt: Point;
  499.                                     modifiers: EventModifiers;
  500.                                     clickTime: LongInt;
  501.                                     hObjectDesc: WEObjectDescHandle): Boolean;
  502.         var
  503.             pDesc: WEObjectDescPtr;
  504.             saveDescLock: Boolean;
  505.     begin
  506.         _WEClickObject := false;        { assume we won't intercept this click }
  507.  
  508. { lock the object descriptor }
  509.         saveDescLock := _WESetHandleLock(hObjectDesc, true);
  510.         pDesc := hObjectDesc^;
  511.  
  512.         if (pDesc^.objectTable <> nil) then
  513.             with WEOHTableHandle(pDesc^.objectTable)^^[pDesc^.objectIndex] do
  514.                 begin
  515.  
  516. {$IFC WASTE_DEBUG}
  517. { sanity check: make sure object kind matches handler kind }
  518.                     _WEAssert(pDesc^.objectType = objectType, 'Object Type Mismatch');
  519. {$ENDC}
  520.  
  521. { call the click handler, if any }
  522.                     if (clickHandler <> nil) then
  523.                         _WEClickObject := CallWEClickObjectProc(hitPt, modifiers, clickTime, hObjectDesc, clickHandler);
  524.  
  525.                 end;
  526.  
  527. { unlock the object descriptor }
  528.         if (_WESetHandleLock(hObjectDesc, saveDescLock)) then
  529.             ;
  530.  
  531.     end;  { _WEClickObject }
  532.  
  533.     function WEInstallObjectHandler (objectType: OSType;
  534.                                     handlerSelector: OSType;
  535.                                     handler: UniversalProcPtr;
  536.                                     hWE: WEHandle): OSErr;
  537.         label
  538.             1;
  539.         var
  540.             hTable: Handle;
  541.             index: Integer;
  542.             element: WEOHTableElement;
  543.             err: OSErr;
  544.     begin
  545.  
  546. { if hWE is NIL, install the handler in the global handler table, }
  547. { otherwise install the handler in the instance-specific handler table }
  548.         if (hWE = nil) then
  549.             hTable := _weGlobalObjectHandlerTable
  550.         else
  551.             hTable := hWE^^.hObjectHandlerTable;
  552.  
  553. { create the handler table, if it doesn't exist }
  554.         if (hTable = nil) then
  555.             begin
  556.                 hTable := NewHandle(0);
  557.                 err := MemError;
  558.                 if (err <> noErr) then
  559.                     goto 1;
  560.                 if (hWE = nil) then
  561.                     _weGlobalObjectHandlerTable := hTable
  562.                 else
  563.                     hWE^^.hObjectHandlerTable := hTable;
  564.             end;
  565.  
  566. { look for the entry corresponding to the specified object type }
  567.         index := _WELookupObjectType(objectType, hTable);
  568.  
  569.         if (index = kUnknownObjectType) then
  570.             begin
  571.  
  572. { previously unknown object type: append a new entry at the end of the handler table }
  573.                 index := Integer(GetHandleSize(hTable)) div SizeOf(WEOHTableElement);
  574.                 _WEBlockClr(@element, SizeOf(element));
  575.                 element.objectType := objectType;
  576.                 err := _WEInsertSlot(hTable, @element, index, SizeOf(element));
  577.                 if (err <> noErr) then
  578.                     goto 1;
  579.             end;
  580.  
  581. { install the handler }
  582.         with WEOHTableHandle(hTable)^^[index] do
  583.             err := _WESetField(_WEObjectHandlerSelectorTable, handlerSelector, @handler, @objectType);
  584.  
  585. 1:
  586. { return result code }
  587.         WEInstallObjectHandler := err;
  588.  
  589.     end;  { WEInstallObjectHandler }
  590.  
  591. {$IFC GENERATINGCFM}
  592.  
  593.     function NewWENewObjectProc (userRoutine: WENewObjectProcPtr): WENewObjectUPP;
  594.     begin
  595.         NewWENewObjectProc := NewRoutineDescriptor(userRoutine, uppWENewObjectProcInfo, GetCurrentArchitecture);
  596.     end;  { NewWENewObjectProc }
  597.  
  598.     function NewWEDisposeObjectProc (userRoutine: WEDisposeObjectProcPtr): WEDisposeObjectUPP;
  599.     begin
  600.         NewWEDisposeObjectProc := NewRoutineDescriptor(userRoutine, uppWEDisposeObjectProcInfo, GetCurrentArchitecture);
  601.     end;  { NewWEDisposeObjectProc }
  602.  
  603.     function NewWEDrawObjectProc (userRoutine: WEDrawObjectProcPtr): WEDrawObjectUPP;
  604.     begin
  605.         NewWEDrawObjectProc := NewRoutineDescriptor(userRoutine, uppWEDrawObjectProcInfo, GetCurrentArchitecture);
  606.     end;  { NewWEDrawObjectProc }
  607.  
  608.     function NewWEClickObjectProc (userRoutine: WEClickObjectProcPtr): WEClickObjectUPP;
  609.     begin
  610.         NewWEClickObjectProc := NewRoutineDescriptor(userRoutine, uppWEClickObjectProcInfo, GetCurrentArchitecture);
  611.     end;  { NewWEClickObjectProc }
  612.  
  613.     function CallWENewObjectProc(var defaultObjectSize: Point; objectRef: WEObjectDescHandle; userRoutine: WENewObjectUPP): OSErr;
  614.     begin
  615.         CallWENewObjectProc := CallUniversalProc(userRoutine, uppWENewObjectProcInfo, defaultObjectSize, objectRef);
  616.     end; { CallWENewObjectProc }
  617.     
  618.     function CallWEDisposeObjectProc(objectRef: WEObjectDescHandle; userRoutine: WEDisposeObjectUPP): OSErr;
  619.     begin
  620.         CallWEDisposeObjectProc := CallUniversalProc(userRoutine, uppWEDisposeObjectProcInfo, objectRef);
  621.     end; { CallWEDisposeObjectProc }
  622.     
  623.     function CallWEDrawObjectProc({const} var destRect: Rect; objectRef: WEObjectDescHandle; userRoutine: WEDrawObjectUPP): OSErr;
  624.     begin
  625.         CallWEDrawObjectProc := CallUniversalProc(userRoutine, uppWEDrawObjectProcInfo, destRect, objectRef);
  626.     end; { CallWEDrawObjectProc }
  627.     
  628.     function CallWEClickObjectProc(hitPt: Point; modifiers: Integer; clickTime: LongInt; objectRef: WEObjectDescHandle; userRoutine: WEClickObjectUPP): Boolean;
  629.     begin
  630.         CallWEClickObjectProc := Boolean(CallUniversalProc(userRoutine, uppWEClickObjectProcInfo, hitPt, modifiers, clickTime, objectRef));
  631.     end; { CallWEClickObjectProc }
  632.     
  633. {$ENDC}
  634.  
  635. end.